using Microsoft.AspNetCore.Mvc;
using Order.Api.Read.Dto.Order;
using Order.Api.Read.Service.MedicalAIService;
using Order.ErrorCode;

namespace Order.Api.Read.Controllers
{
    /// <summary>
    /// 医疗AI控制器
    /// 提供医疗AI相关的API接口，包括处方分析、诊断建议、药品相互作用检查等功能
    /// 所有接口都返回统一的ApiResult格式
    /// </summary>
    [ApiController]
    [Route("api/[controller]/[action]")]
    public class MedicalAIController : ControllerBase
    {
        /// <summary>
        /// AI服务实例，用于调用各种医疗AI功能
        /// </summary>
        private readonly IMedicalAIService _aiService;

        /// <summary>
        /// 日志记录器，用于记录控制器操作的日志信息
        /// </summary>
        private readonly ILogger<MedicalAIController> _logger;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="aiService">医疗AI服务实例</param>
        /// <param name="logger">日志记录器实例</param>
        public MedicalAIController(IMedicalAIService aiService, ILogger<MedicalAIController> logger)
        {
            _aiService = aiService;
            _logger = logger;
        }

        /// <summary>
        /// 测试AI服务连接
        /// 用于验证AI服务是否正常运行，通常在系统启动时或定期检查时调用
        /// </summary>
        /// <returns>
        /// ApiResult<string> 包含连接测试结果
        /// - 成功：返回"AI服务连接正常"
        /// - 失败：返回具体的错误信息
        /// </returns>
        [HttpGet]
        public async Task<ApiResult<string>> TestConnection()
        {
            try
            {
                // 调用AI服务的连接测试方法
                var isConnected = await _aiService.TestConnectionAsync();
                if (isConnected)
                {
                    return new ApiResult<string> { Code = ApiEnums.Success, Data = "AI服务连接正常", Msg = "连接测试成功" };
                }
                else
                {
                    return new ApiResult<string> { Code = ApiEnums.Error, Data = "AI服务连接失败", Msg = "连接测试失败" };
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "测试AI服务连接时发生错误");
                return new ApiResult<string> { Code = ApiEnums.Error, Data = "AI服务连接异常", Msg = "连接测试异常" };
            }
        }

        /// <summary>
        /// 分析处方内容
        /// 对医生开具的处方进行智能分析，提供专业的医疗建议
        /// </summary>
        /// <param name="request">包含处方文本的请求对象</param>
        /// <returns>
        /// ApiResult<string> 包含AI生成的处方分析报告
        /// </returns>
        [HttpPost]
        public async Task<ApiResult<string>> AnalyzePrescription([FromBody] PrescriptionAnalysisRequest request)
        {
            try
            {
                // 验证输入参数
                if (string.IsNullOrWhiteSpace(request.PrescriptionText))
                {
                    return new ApiResult<string> { Code = ApiEnums.Error, Msg = "处方内容不能为空" };
                }

                // 调用AI服务进行处方分析
                var result = await _aiService.AnalyzePrescriptionAsync(request.PrescriptionText);
                return new ApiResult<string> { Code = ApiEnums.Success, Data = result, Msg = "处方分析成功" };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "分析处方时发生错误");
                return new ApiResult<string> { Code = ApiEnums.Error, Msg = "分析处方时发生错误" };
            }
        }

        /// <summary>
        /// 生成医疗报告
        /// 根据患者信息和订单数据生成专业的医疗报告
        /// </summary>
        /// <param name="request">包含患者信息和订单数据的请求对象</param>
        /// <returns>
        /// ApiResult<string> 包含生成的医疗报告
        /// </returns>
        [HttpPost]
        public async Task<ApiResult<string>> GenerateMedicalReport([FromBody] MedicalReportRequest request)
        {
            try
            {
                // 验证输入参数
                if (request.Patient == null)
                {
                    return new ApiResult<string> { Code = ApiEnums.Error, Msg = "患者信息不能为空" };
                }

                // 调用AI服务生成医疗报告
                var result = await _aiService.GenerateMedicalReportAsync(request.Patient, request.OrderData);
                return new ApiResult<string> { Code = ApiEnums.Success, Data = result, Msg = "医疗报告生成成功" };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "生成医疗报告时发生错误");
                return new ApiResult<string> { Code = ApiEnums.Error, Msg = "生成医疗报告时发生错误" };
            }
        }

        /// <summary>
        /// 获取诊断建议
        /// 根据症状描述和患者病史提供初步诊断建议
        /// 注意：这只是AI辅助建议，最终诊断需要专业医生确认
        /// </summary>
        /// <param name="request">包含症状描述和病史的请求对象</param>
        /// <returns>
        /// ApiResult<string> 包含AI生成的诊断建议
        /// </returns>
        [HttpPost]
        public async Task<ApiResult<string>> GetDiagnosticSuggestion([FromBody] DiagnosticRequest request)
        {
            try
            {
                // 验证输入参数
                if (string.IsNullOrWhiteSpace(request.Symptoms))
                {
                    return new ApiResult<string> { Code = ApiEnums.Error, Msg = "症状描述不能为空" };
                }

                // 调用AI服务获取诊断建议
                var result = await _aiService.GetDiagnosticSuggestionAsync(request.Symptoms, request.PatientHistory ?? "");
                return new ApiResult<string> { Code = ApiEnums.Success, Data = result, Msg = "诊断建议获取成功" };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "获取诊断建议时发生错误");
                return new ApiResult<string> { Code = ApiEnums.Error, Msg = "获取诊断建议时发生错误" };
            }
        }

        /// <summary>
        /// 检查药品相互作用
        /// 分析多个药品之间是否存在相互作用
        /// </summary>
        /// <param name="request">包含药品列表的请求对象</param>
        /// <returns>
        /// ApiResult<string> 包含药品相互作用分析结果
        /// </returns>
        [HttpPost]
        public async Task<ApiResult<string>> CheckDrugInteractions([FromBody] DrugInteractionRequest request)
        {
            try
            {
                // 验证输入参数
                if (request.DrugList == null || !request.DrugList.Any())
                {
                    return new ApiResult<string> { Code = ApiEnums.Error, Msg = "药品列表不能为空" };
                }

                // 调用AI服务检查药品相互作用
                var result = await _aiService.CheckDrugInteractionsAsync(request.DrugList);
                return new ApiResult<string> { Code = ApiEnums.Success, Data = result, Msg = "药品相互作用检查成功" };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "检查药品相互作用时发生错误");
                return new ApiResult<string> { Code = ApiEnums.Error, Msg = "检查药品相互作用时发生错误" };
            }
        }

        /// <summary>
        /// 生成健康建议
        /// 根据患者信息和订单历史生成个性化的健康建议
        /// </summary>
        /// <param name="request">包含患者信息和订单历史的请求对象</param>
        /// <returns>
        /// ApiResult<string> 包含个性化的健康建议
        /// </returns>
        [HttpPost]
        public async Task<ApiResult<string>> GenerateHealthAdvice([FromBody] HealthAdviceRequest request)
        {
            try
            {
                // 验证输入参数
                if (request.Patient == null)
                {
                    return new ApiResult<string> { Code = ApiEnums.Error, Msg = "患者信息不能为空" };
                }

                // 调用AI服务生成健康建议
                var result = await _aiService.GenerateHealthAdviceAsync(request.Patient, request.OrderHistory ?? new List<object>());
                return new ApiResult<string> { Code = ApiEnums.Success, Data = result, Msg = "健康建议生成成功" };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "生成健康建议时发生错误");
                return new ApiResult<string> { Code = ApiEnums.Error, Msg = "生成健康建议时发生错误" };
            }
        }


    }

    #region 请求模型

    /// <summary>
    /// 处方分析请求模型
    /// 用于接收前端发送的处方分析请求
    /// </summary>
    public class PrescriptionAnalysisRequest
    {
        /// <summary>
        /// 处方文本内容
        /// 包含药品名称、剂量、用法等处方信息
        /// </summary>
        public string PrescriptionText { get; set; } = "";
    }

    /// <summary>
    /// 医疗报告请求模型
    /// 用于接收前端发送的医疗报告生成请求
    /// </summary>
    public class MedicalReportRequest
    {
        /// <summary>
        /// 患者基本信息
        /// 包括姓名、年龄、性别、联系方式等
        /// </summary>
        public PatientDto Patient { get; set; } = new();

        /// <summary>
        /// 订单相关数据
        /// 可以是药品订单、问诊订单等具体订单信息
        /// </summary>
        public object OrderData { get; set; } = new();
    }

    /// <summary>
    /// 诊断请求模型
    /// 用于接收前端发送的诊断建议请求
    /// </summary>
    public class DiagnosticRequest
    {
        /// <summary>
        /// 患者症状描述
        /// 如"头痛、发热、咳嗽"等具体症状
        /// </summary>
        public string Symptoms { get; set; } = "";

        /// <summary>
        /// 患者病史信息
        /// 包括既往疾病、过敏史等，可以为null
        /// </summary>
        public string? PatientHistory { get; set; }
    }

    /// <summary>
    /// 药品相互作用请求模型
    /// 用于接收前端发送的药品相互作用检查请求
    /// </summary>
    public class DrugInteractionRequest
    {
        /// <summary>
        /// 需要检查的药品列表
        /// 包含药品名称的字符串列表
        /// </summary>
        public List<string> DrugList { get; set; } = new();
    }

    /// <summary>
    /// 健康建议请求模型
    /// 用于接收前端发送的健康建议生成请求
    /// </summary>
    public class HealthAdviceRequest
    {
        /// <summary>
        /// 患者基本信息
        /// </summary>
        public PatientDto Patient { get; set; } = new();

        /// <summary>
        /// 患者的历史订单记录
        /// 用于分析患者的健康状况和就医模式，可以为null
        /// </summary>
        public List<object>? OrderHistory { get; set; }
    }

    #endregion
}